interface IUser {
    cname: string;
    age: number;
    type: string;
}
let arr: IUser[] = [
    { cname: '张三', age: 18, type: 'admin' },
    { cname: '李四', age: 20, type: 'user' },
    { cname: '王五', age: 22, type: 'admin' }
];
let arrObject = new Array(4); // 创建一个长度为4的数组
for( let i = 0; i < arrObject.length; i++ ) {
    arrObject[i] = i * 2;
}
console.log(arrObject);// [ 0, 2, 4, 6 ]

// 遍历数组
let list : string[] = [ "Google", "Runoob", "Taobao", "Facebook" ];
for( let i = 0; i < list.length; i++ ) {
    console.log(list[i]);
}

// 数组解构
let [g, r, t , fb] = list;
console.log(g, r, t, fb);

// 遍历数组
for( let index in arr ) {
    console.log(arr[index]);
}
// 遍历数组
for( let item of arr ) {
    console.log(item);
}

//多维数组遍历
let arr3 :number[][] = [[1,2,3],[4,5,6],[7,8,9]];
arr3.forEach(item => {
    item.forEach(item1 => {
        console.log(item1);
    });
});
console.log(arr3);

// concat：合并两个或多个数组，并返回一个新的数组。
let arrayConcat1 = [1, 2, 3].concat([4, 5, 6]);
console.log(arrayConcat1);

// every：遍历数组的每个元素，如果所有元素满足指定的回调函数的条件，则返回true，否则返回false。
let pass = [1, 2, 3].every(item => {
    return item > 2;
});
console.log(pass);

// some：遍历数组的每个元素，如果至少有一个元素满足指定的回调函数的条件，则返回true，否则返回false。
let pass1 = [1, 2, 3].some(item => {
    return item > 2;
});
console.log(pass1);

// filter：遍历数组的每个元素，如果满足指定的回调函数的条件，则返回true，否则返回false。
let arrFilter = arr.filter(item => {
    return item.type === 'admin';
});
console.log(arrFilter);

// find：遍历数组的每个元素，如果满足指定的回调函数的条件，则返回该元素，否则返回undefined。
let arrFind = arr.find(item => {
    return item.type === 'admin';
});
console.log(arrFind);

// findIndex：遍历数组的每个元素，如果满足指定的回调函数的条件，则返回该元素的索引，否则返回-1。
let arrFindIndex = arr.findIndex(item => {
    return item.type === 'admin';
});
console.log(arrFindIndex);

// indexOf：遍历数组的每个元素，如果满足指定的回调函数的条件，则返回该元素的索引，否则返回-1。
let arrIndexOf = [1, 2, 3].indexOf(2);
console.log(arrIndexOf);

// join：将数组中的元素连接成一个字符串，并返回该字符串。
console.log(list.join(','));

// lastIndexOf：遍历数组的每个元素，如果满足指定的回调函数的条件，则返回该元素的索引，否则返回-1。
let arrLastIndexOf = list.lastIndexOf('Runoob');
console.log(arrLastIndexOf);

// map：遍历数组的每个元素，执行指定的回调函数，并返回一个新的数组。
let arr1 = arr.map(item => item?.cname ?? null);
console.log(arr1);

// pop：删除数组的最后一个元素，并返回该元素。原数组会被修改
// push：添加一个或多个元素到数组的末尾，并返回数组的新长度。原数组会被修改
let arrPop0 = [1, 2, 3];
let arrPop1 = arrPop0.pop();
arrPop0.push(4);
console.log(arrPop0, arrPop1);

// reduce：遍历数组的每个元素，执行指定的回调函数，并返回一个值。
let arrReduce = arr.reduce((accumulator, currentValue) => {
    return accumulator + currentValue.age;
}, 0);
console.log(arrReduce);

// reduceRight：遍历数组的每个元素，从右向左执行指定的回调函数，并返回一个值。
let arrReduceRight = arr.reduceRight((accumulator, currentValue) => {
    return accumulator + currentValue.age;
}, 0);
console.log(arrReduceRight);

// reverse：反转数组的顺序，并返回反转后的数组。原数组会被修改
arr.reverse();
console.log(arr);

// shift：删除数组的第一个元素，并返回该元素。原数组会被修改
let arrShift = arr.shift();
console.log(arrShift);

// slice：返回一个新数组，该数组是原始数组的指定部分。
let arrSlice = arr.slice(1, 2); // 从索引1开始，到索引2结束，但不包括索引2
console.log(arrSlice);

// splice：删除数组的指定元素，并返回被删除的元素。原数组会被修改
let arrSplice = [1, 2, 3];
arrSplice.splice(1, 1, 4, 5);// 从索引1开始，删除1个元素，添加2个元素
console.log(arrSplice);
arrSplice.splice(1, 0, 4, 5);// 从索引1开始，不删除元素，添加2个元素
console.log(arrSplice);
arrSplice.splice(1, 2);// 从索引1开始，删除2个元素
console.log(arrSplice);

// sort：对数组进行排序，并返回排序后的数组。原数组会被修改
let arrSort = [1, 5, 6, 3, 2, 7, 9, 8];
arrSort.sort((a, b) => {
    return a - b;
});
console.log(arrSort);

// sort：根据对象数组的对象属性进行排序，排序。
let arrSort1 = [
    { name: '张三', age: 18 },
    { name: '李四', age: 16 },
    { name: '王五', age: 22 }
];
arrSort1.sort((a, b) => {
    return a.age - b.age;
});
// [ { name: '李四', age: 16 }, { name: '张三', age: 18 }, { name: '王五', age: 22 } ]
console.log(arrSort1);

// unshift：添加一个或多个元素到数组的开头，并返回数组的新长度。原数组会被修改
let arrUnshift = [1, 2, 3];
arrUnshift.unshift(4)
console.log(arrUnshift);// [4, 1, 2, 3]